Microprocessors II מ יקרו-מ עבדים ב' סמסטר א' תשס"ט

Size: px

Start display at page:

Download "Microprocessors II מ יקרו-מ עבדים ב' סמסטר א' תשס"ט"

Anabel Lynch
6 years ago
Views:

1 1 1 מ יקרו-מ עבדים ב' סמסטר א' תשס"ט המרצה: ד"ר מרטין לנד

2 1 2 מיקרו-מעבדים בתוכנית הלימודים בהדסה מ ערכות ספרתיות שיטות פורמליות ואבני היסוד של חומרה מ יקרו-מעבדי ם א' כיצד המחשב הכללי מאורגן מבוא לשפת סף מ יקרו-מעבדי ם ב' תכנות מודרנית בשפת סף הבנת הפעולות במחשב ה- מ ערכות הפעלה PC ה כללי שירותי תיווך בין חומרת המחשב והמשתמש ארכיטקטורות של מ ח שבים תקשורת ביצועים במחשבים ושיטות מודרניות בתכנון מחשבים חיבור בין מחשבים בתוכנה ובחומרה

3 1 3 סילבוס רענון קצר על 8086 תכנות שפת סף עם כלים מקצועיים (NASM/MASM) מבנה של מחשב PC מצוי (ממשקים, קלט/פלט, ציוד היקפי, אפיקי ISA ו- (AGP,USB,PCI תכנות מערכת (זיכרון, קלט/פלט, (drivers 32-bit למעבדי Intel המבנה המודרני של IA-32 והמעבד

4 1 4 ספ ר י לימוד האוניברסיטה הפתוחה, משפחת המע בדים 8086 משה קליג' ועידו שרון, המחשב האישי למשתמש המקצועי, הוצאת הוד-עמי, NASM User Manual (on course web site) Intel386 TM DX Microprocessor (on course web site) V. Carl Hamacher, Zvonko G. Vranesic, Safwat G. Zaky, Computer Organization, McGraw-Hill. Tom Shanley and Don Anderson, ISA System Architecture, Mindshare, Inc., Tom Shanley and Don Anderson, PCI System Architecture, Mindshare, Inc., 1995.

5 1 5 ציונים הציון בקורס נקבע ע"י מבחן סמסטר (80%).(20%) ותרגילים הגשת 80% מהתרגילים חובה כל אחד יגיש בנפרד ובני סוח אישי. על כל שבוע איחור, יורדו 10 נקודות מציון התרגיל, ותרגיל לא יתקבל אחרי שהפתרון ניתן בכיתה. הגשת תרגיל באיחור עקב היעדרות כלשהי מותנית בהצגת איש ורים מתאימים בפני המרצה.

6 1 6 שמיר ת ק ש ר אתר הקורס דרך מערכת מידע אישי שע ו ת קבלה: דואר אלקטרוני: יום ה' 16:00 15:00 martin@multinet.net.il תמיד ני תן לפנות אלי בדואר אלקטרוני לכלול את הביטוי Micro בנושא ההודעה

7 1 7 Coding Example dseg segment para public 'data' string1 byte "hello world",0dh,0ah,0 dseg ends cseg segment para public 'code' assume cs:cseg, ds:dseg Main proc near mov ax, seg dseg mov ds, ax lea si, string1 call pr_str call ExitPgm ret Main endp ExitPgm proc near mov ah,4ch int 21h ret ExitPgm endp pr_str proc near mov ah,02h next: lodsb cmp al,00h jz p_fin mov dl,al int 21h jmp next p_fin: ret pr_str endp cseg ends end Main

8 1 8 Review of Intel 8086 Architecture

9 Implementation General Registers AH BH CH DH BP SP SI DI AL BL CL DL AX BX CX DX ALU ALU_IN ALU ALU_OUT Status Word Decoder and Control Execution Unit (EU) Instruction Pointer and Segment Registers IP CS DS SS ES OFF SEG BASE INDEX DISP Physical Address Unit (PAU) System Bus PA Address Bus Control (MAR) Instruction Queue Decoder Data Bus Control (MDR) Bus Interface Unit (BIU) PA = 10 SEG + BASE + INDEX + DISP 20 bits 16 bits Physical Address Control Main Memory Data

10 1 10 Four Segments Registers in 8086 Code Data Stack Extra 15 0 CS DS SS ES RAM ES Remember four different segments at same time Code Segment (CS) program code Stack Segment (SS) user Data Segment (DS) program data Extra Segment (ES) extra program data SS CS DS

11 1 11 General and Status Registers AH AL AX Accumulator BH BL BX Base CH CL CX Count DH DL DX Data Stack Pointer Base Pointer Source Index Destination Index Instruction Pointer 15 0 SP BP SI DI IP Status Register 15 0

12 1 12 Default Segments Automatic Addresses Memory Access Logical Address Physical Address Instruction Fetch CS:IP CS 10h+IP Stack Operation SS:SP SS 10h+SP String Destination ES:DI ES 10h+DI String Source DS:SI DS 10h+SI Effective Address (EA) Addresses for General Data Access BP BX + SI DI + Displacement Default Physical Address = DS 10h + Effective Address If EA includes BP, Physical Address = SS 10h + EA Instruction can override DS or SS to CS, ES, SS

13 1 13 Status Registers Bit Position Name Function 0 CF Carry Flag 2 PF Parity Flag - set for even number of 1 s in low order byte 4 AF Carry on low order 4-bits of AL 6 ZF Zero Result 7 SF Sign of Result 8 TF Stops after next instruction and resets TF (for single step) 9 IF Interrupt Enable 10 DF Causes string instructions to autodecrement index register (otherwise, autoincrement) 11 OF Overflow

14 1 14 Instruction Types ALU operations Mostly 2 operand operations (changes one of the inputs) Defined for byte or word operations Some require operands to be in specific registers Transfer operations String operations Control operations Conditional and unconditional branch Loop Subroutine Stack operations Push/Pop

15 1 15 Basic Instructions MOV DEST, SRC DEST SRC LEA DEST, [EA] DEST EA PUSH SRC SP SP - 2 [SS:SP] SRC POP DEST DEST [SS:SP] SP SP + 2 LDS DEST, [EA] DEST [EA] DS [EA+2] IN ACC, PORT ACC input OUT PORT, ACC output ACC ALU_OP DEST, SRC DEST DEST OP SRC ALU_Ops: NOT, AND, OR, TEST, XOR, ADD, SUB, INC, DEC, NEG, CMP, MUL, IMUL, DIV, IDIV JMP NEAR TARGET IP TARGET JMP FAR TARGET CS:IP TARGET J(CONDITION) SHORT TARGET IP TARGET ON CONDITION JC, JNC, JZ, JNZ, JG, JLE, JGE, JL, JO, JS, JNO, JNS LOOP SHORT TARGET CX CX 1 IP TARGET IF CX 0 CALL NEAR TARGET PUSH IP IP TARGET CALL FAR TARGET PUSH CS:IP CS:IP TARGET RET POP IP RETF POP CS:IP SHR, SAR, SAL SHIFT BITS INT N PUSH FLAGS, CS:IP CS:IP [4 * N] STOSB [ES:DI] AL DI DI ± 1 LODSB AL [DS:SI] SI SI ± 1

16 1 16 The Assembly Language Programming Process 1. Top-down design 1. High level design 2. Organization into modules and functions 2. Coding the modules 1. Defining local data structures and coding 2. Writing assembly language code for each module 3. Assembly 1. Converting assembly code to machine code and resolving internal references 2. Hand assembly or by assembler (program) 4. Linking 1. Resolving external address references for jump and call instructions, and creating a program file 2. Hand linking or by linker (program) 5. Loading 1. Placing program in memory to run 2. Hand loading or by loader (program)

17 1 17 Microsoft Memory Models Tiny model All data, code, in one 64 KB segment CS = DS = ES = SS Small model One segment each for code, data, CS DS SS Medium model One segment each for code, Change value of data segment register as necessary CS SS DS 1 DS 2 DS 3 Compact model One segment each for data, Change value of code segment register as necessary DS SS CS 1 CS 2 CS 3 Large model SS DS 1 DS 2 DS 3 CS 1 CS 2 CS 3

18 1 18 Storing Variables 1 Global Accessible by all modules Any running code can read or write value Local Defined for one module Only one a module can read or write value Stored in separate sections of memory Module 3 Local Data Module 2 Local Data Module 1 Local Data Module 3 Code Module 2 Code Module 1 Code Global Data

19 1 19 Global Variables Store global in default data segment Begin at address DS:[0000] Allow 2 bytes per integer (16-bit integers) 1 or 2 bytes per character (8-bit characters) Continue in order of definition Example DS:0008 DS:0007 DS:0006 DS:0005 DS:0004 DS:0003 DS:0002 DS:0001 DS:0000 Y (high byte) Y (low byte) 'C' X (high byte) X (low byte)

20 1 20 Data Frame with BP for Local Variables Stack segment frame Segment register SS is fixed First variable stored at address SS:[BP-02] Second variable stored at address SS:[BP-04] Third variable stored at address SS:[BP-06] Continue in order of definition User starts below variable definitions Used for local by most C compilers SS:BP-1 SS:BP-2 SS:BP-3 SS:BP-4 SS:BP-5 SS:BP-6 SS:BP-7 SS:BP-8 = SS:SP X (H) X (L) 'C' Y (H) Y (L) Z (H) Z (L) Empty Part of Stack

21 1 21 () { int x = 1; long y = 2; char q = '3'; int z = 4; int a[3]; int b = 5; a[0] = 6; a[1] = 7; a[2] = 8; } MOV WORD PTR [BP-02],0001 MOV WORD PTR [BP-04],0000 MOV WORD PTR [BP-06],0002 MOV BYTE PTR [BP-07],33 MOV WORD PTR [BP-0A],0004 MOV WORD PTR [BP-12],0005 MOV WORD PTR [BP-10],0006 MOV WORD PTR [BP-0E],0007 MOV WORD PTR [BP-0C],0008 Variable Allocation x (H) 00 BP-01 x (L) 01 BP-02 y (3) 00 BP-03 y (2) 00 BP-04 y (1) 00 BP-05 y (0) 02 BP-06 q 33 BP-07 XX BP-08 z (H) 00 BP-09 z (L) 04 BP-0A a[2] (H) 00 BP-0B a[2] (L) 08 BP-0C a[1] (H) 00 BP-0D a[1] (L) 07 BP-0E a[0] (H) 00 BP-0F a[0] (L) 06 BP-10 b (H) 00 BP-11 b (L) 05 BP-12

22 1 22 for Loop Example () { int i,j; for (i = 0; i < 10; i++){ j = 2 * i; } } 0B3B:0009 MOV WORD PTR [BP-02],0000 ; i = 0 0B3B:000E CMP WORD PTR [BP-02],+0A 0B3B:0012 JGE 0021 ; break on i 10 0B3B:0014 MOV AX,[BP-02] ; AX i 0B3B:0017 SHL AX,1 ; AX 2 * AX 0B3B:0019 MOV [BP-04],AX ; j AX 0B3B:001C INC WORD PTR [BP-02] ; i++ 0B3B:001F JMP 000E ; loop 0B3B:0021

23 1 23 () { int N, M = 1; for (N = 2 ; N <= 7 ; ++N){ M = N * M; } } C Versus Assembly 0B3B:0009 MOV WORD PTR [BP-04],0001 ; M = [BP-04] 1 0B3B:000E MOV WORD PTR [BP-02],0002 ; N = [BP-02] 2 0B3B:0013 CMP WORD PTR [BP-02],+07 ; compare N with 7 0B3B:0017 JG 0027 ; break if N > 7 0B3B:0019 MOV AX,[BP-02] ; AX N 0B3B:001C IMUL WORD PTR [BP-04] ; AX AX * M 0B3B:001F MOV [BP-04],AX ; M AX 0B3B:0022 INC WORD PTR [BP-02] ; ++N 0B3B:0025 JMP 0013 ; loop 0B3B:0027 0B3B:0100 MOV CX,0007 ; counter CX 7 0B3B:0103 MOV AX,0001 ; accumulator AX 1 0B3B:0106 IMUL CX ; AX AX * CX 0B3B:0108 LOOP 0106 ; CX-- loop if CX!= 0 0B3B:010A MOV [BP-02],AX ; M AX

24 1 24 Program Modules Address Resolution module calls function and function can be coded and assembled separately Efficient control of long programs : end: function: up: MOV AX,BX ADD AX,[0012] CALL function RET POP AX MOV CX,20 MUL CX LOOP up RET Assembling.asm produces.obj Contains CALL to unresolved external reference Assembling function.asm produces function.obj Contains LOOP to resolved internal reference

25 1 25 Linking Combines Separate Object Files Creates program file (.sys,.com, or.exe) Creates Program Header (for.exe files) Puts all code and data segments into program file Orders segments in a standard way Resolve references between modules Higher Addresses Stack Segment Module 2 (Function) Data Segment Module 2 (Function) Code Segment Default (Main) Code Segment Default (Main) Data Segment Program Header

26 1 26 Directives in Assembly Language Programming Feature of Assembler programming environment Not part of machine language instruction set Not available when hand assembling Cause assembler to perform certain actions during assembly Allocate memory Translate symbolic variable names to memory locations Depends on assembler Examples: DB 02, 03, 04 ; inserts 3 data bytes between ; instructions DW VAR1 02 ; defines variable VAR1 and assigns ; VAR1 = 0002 PUSH VAR1 ; references variable VAR1 LEA BX, VAR1 ; places pointer to VAR1 (location of its ; value in memory) into BX

27 1 27 Features of Common Assembler Programs debug.exe Free included with DOS and Windows Limited directives (no line labels or ) Assembly and disassembly Complete execution environment, with register checking, tracing, and debugging MASM/TASM Commercial software (Microsoft/Borland) Powerful directives for complete programming environment (, data structures, labels, procedures, etc.) Assembly only No execution or debugging features NASM Free, open source version of MASM and TASM

28 1 28 Modular Programming (Main + Functions) Easier to read and understand code Write, debug, and change modules independently Write some modules in high level language Compiler creates object code Machine code w/o linked addresses Write critical sections in assembly language Link together at end Pass local to functions as parameters.c compile.obj link prog.exe f1.asm assemble f1.obj f2.c compile f2.obj load f_std.lib

29 1 29 C Style Assembly Code Programs built from Global Functions Local defined within scope of a function Default function is called Code within may call other functions Code within a function may call other functions Code within a function may call itself Recursion requires reentrant code Each instance of function has private data memory for local function_1 function_2 function_3

30 1 30 Store global according to int_g0 DS:0 int_g1 DS:2 int_g2 DS: Friendly Model 1 Local data frame in segment Store local at top of frame int_0 SS:BP-02 int_1 SS:BP-04 int_2 SS:BP-06 Store local below local Stack expands down (SP SP 2) Data frame boundaries SS:BP points to top of frame SS:SP points to bottom of frame Change SS only if necessary SS:BP SS:SP DS:00 CS:IP function_1 function_1 function_2 function_2 function_3 function_3 function_3 function_3 global function_3 function_2 function_1

31 Friendly Model 2 Data frame boundaries SS:BP points to top of frame SS:SP points to bottom of frame Empty : SP = BP 2 bytes per variable defined in function On function call New data frame for called function SS:BP Begins below data frame for calling function Save BP calling (to use on return to calling function) Top of new frame is bottom of old frame BP called SP calling New starts below new SP called SP calling - size of variable data SP called expands down (SP SP 2) SS:BP SS:SP SS:SP DS:00 CS:IP CS:IP function_1 function_1 function_2 function_2 function_3 function_3 function_3 function_3 global function_3 function_2 function_1

32 1 32 Keeping Track of SP and BP Called function performs: SS:BP PUSH BP Saves BP calling on of calling function MOV BP,SP BP called SP calling SUB SP, 2 bytes per defined variable SP calling - size of variable data SP called <Local operations of function> MOV SP,BP Restores SP SP calling POP BP Restores BP calling from of calling function SS:BP SS:SP SS:SP DS:00 CS:IP CS:IP function_1 function_1 function_2 function_2 function_3 function_3 function_3 function_3 global function_3 function_2 function_1

33 1 33 Memory in Time-Sequence code running SS:BP f_1 code running code running SS:BP f_2 code running f_1 code running f_2 code running code running SS:BP SS:SP SS:BP f_1 SS:SP SS:BP f_2 f_2 SS:BP f_2 SS:SP SS:SP f_1 SS:SP f_2 SS:BP f_2 f_1 SS:SP f_2 CS:IP f_1 f_2 global CS:IP f_1 f_2 global CS:IP f_1 f_2 global CS:IP f_1 f_2 global SS:SP CS:IP f_1 f_1 f_2 global CS:IP f_1 f_2 global CS:IP f_1 f_2 global calls f_1 f_1 ends calls f_2 f_2 calls f_1 f_1 ends f_2 ends

34 1 34 Format of the Most General Instruction Each field is one byte long (2 HEX digits) Each field except Opcode is optional Segment Override Opcode mod reg r/m address specifiers Disp8 low order Disp16 high order Imm8 low order Imm16 high order Disp = displacement = numerical addition to address Imm = immediate = numerical value used in ALU operation Example: ES: ADD AX, [BX+SI+1234]

35 1 35 Calling DOS System Functions Operating System calls: Write required parameters to registers AH function code code identifies particular system call Interrupt INT 21 calls DOS function handler DOS runs service function code DOS call returns to user program Check exit conditions error codes returned values

36 1 36 Basic DOS System Calls Function Code Create file 3C Open file 3D Close file 3E Read from file 3F Write to file 40 File read/write pointer 42 Terminate process 4C Get keyboard input 01 Display output 02

37 1 37 The Program Segment Prefix Offset Size Contents 0000h 2 bytes int 20h (old style program terminate command) 0005h 5 bytes FAR call to MSDOS function dispatcher (int 21h) 000Ah 4 bytes Previous termination handler interrupt vector (int 22h) 000Eh 4 bytes Previous contents of ctrl-c interrupt vector (int 23h) 0012h 4 bytes Previous critical error handler interrupt vector (int 24h) 002Ch 2 bytes Segment address of the program's environment block 0080h 1 byte Parameter length (number of chars entered after filename) Becomes Disk Transfer Area (DTA) 0081h 127 bytes Parameters command tail Command tail All characters (including spaces) after file name Example format a: /q command tail = a: /q command tail contains 6 characters Disk Transfer Area (DTA) Used by some DOS functions as default buffer Command tail must be saved before overwritten

38 1 38 Structure of a DOS.com Program Store code code Increasing Addresses data and code load module load module data and code PSP JMP NEAR DS:EA SS:SP start segment = CS:0100 File on Disk File in RAM DS = CS = SS = ES = start segment - 10 Load Module = Code, Program Data, Stack, stored on disk All addresses are relative to the fixed CS = DS = SS = ES Default IP = 0100 Load

39 1 39 Structure of a DOS.exe Program Store SS SS Increasing Addresses CS stored portion of DS header load module load module CS stored portion of DS PSP data segment SS = start segment + ISS CS = start segment + ICS start segment DS = start segment - 10 File on Disk File in RAM Load Load Module = Program data,, code stored on disk ISS = Initial Stack Segment = Offset of SS from start of load module ICS = Initial Code Segment = Offset of CS from start of load module

40 1 40.EXE Program Relocation Far Code Module 5678 bytes CS:IP=0234:5678 CS= =2545 Far Code Module Stack Stack Load Module Default Code JMP FAR [1000] Segment Default Data Segment Header File CS= IP= LOAD bytes Start= bytes Default Code Segment Default Data Segment DOS+PSP RAM In.exe file, FAR segment references are relative to the load module. Relocation: After loading the program, Relocation Items (relative FAR references) are made absolute (SEG SEG + start segment)

41 1 41.EXE Program Header Offset Contents 4D 5A h Linker's signature for a valid.exe file. 00h - 01h (The ASCII letters M and Z, for Mark Zbikowski, a designer of DOS at Microsoft) 02h - 03h (Size of file including header) % (512) 04h - 05h Int [(Size of file including header) / (512)] h - 07h Number of relocation table items following header 08h - 09h Size of header in 16 byte increments (paragraphs) 0Ah - 0Bh Minimum number of 16 byte paragraphs required by program 0Ch - 0Dh Maximum number of 16 byte paragraphs required 0Eh - 0Fh ISS Displacement of segment (in paragraphs) in load module 10h - 11h Starting SP 12h - 13h Word Checksum - negative sum of words in file ignoring overflow 14h - 15h Starting IP 16h - 17h ICS Displacement of code segment (in paragraphs) in load module 18h - 19h Displacement in bytes of first relocation item in file 1Ah - 1Bh Overlay number (0 for the resident part of the program)

42 1 42 debug.exe assemble A compare C dump D enter E fill F go G hex H input I load L move M name N output O proceed P quit Q register R search S trace T unassemble U write W [address] range address [range] address [list] range list [=address] [addresses] value1 value2 port [address] [drive] [firstsector] [number] range address [pathname] [arglist] port byte [=address] [number] [register] range list [=address] [value] [range] [address] [drive] [firstsector] [number]

Microprocessors (A) DOS Services

Microprocessors (A) DOS Services 1 Services 2 System Calls Operating System services: Disk and file system management Screen display and printing Keyboard entry Other I/O management Date and time Program run and terminate Command arguments